//实例内部类
/*public class OuterClass{
    private int a;
    static int b;
    int c;

    public void methodA(){
        a = 10;
        System.out.println(a);
    }

    public static void methodB(){
        b = 20;
        System.out.println(b);
    }

    //实例内部类：未被static修饰
    class InnerClass{
        int c;
        public void methodC(){
            //在实例内部类中可以直接访问外部类中任意限定符修饰的成员
            a= 100;
            b = 200;
            methodA();
            methodB();

            //如果外部类和实例内部类中具有相同名称成员时，有限访问内部类自己的
            c = 300;
            System.out.println(c);

            //如果要访问外部类同名成员的时候，格式：外部类名称.this.同名成员名字
            OuterClass.this.c = 400;
            System.out.println(OuterClass.this.c);
        }
    }

    public static void main(String[] args) {
        //外部类：对象创建及成员访问
        OuterClass out = new OuterClass();
        System.out.println(out.a);
        System.out.println(out.b);
        System.out.println(out.c);
        out.methodA();
        out.methodB();

        System.out.println("====以下是实例内部类的访问====");
        //要访问实例内部类中成员，必须要创建实例内部类的对象
        //而普通内部类定义与外部类成员定义位置相同，因此创建实例内部类对象时必须借助外部类

        //创建实例内部类对象
        OuterClass.InnerClass inn1 = new OuterClass().new InnerClass();

        //上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建实例化内部类对象
        OuterClass.InnerClass inn2 = out.new InnerClass();
        inn2.methodC();
    }
}*/

//静态内部类
/*public class OuterClass{
    private int a;
    static int b;

    public void methodA(){
        a = 10;
        System.out.println(a);
    }

    public static void methodB(){
        b = 20;
        System.out.println(b);
    }

    //静态内部类：被static修饰的成员内部类
    static class InnerClass{
        public void methodC(){
            //在内部类中只能访问外部类的静态成员
            // a = 100;//编译失败，因为a不是静态成员变量（类成员变量）
            b = 200;
            //methodA();//编译失败，因为methodA不是静态成员方法（类成员方法）
            System.out.println(b);
        }
    }

    public static void main(String[] args) {
        //外部类：对象创建及成员访问
        OuterClass out = new OuterClass();
        System.out.println(out.a);
        System.out.println(out.b);
        out.methodA();
        out.methodB();

        System.out.println("====以下是静态内部类的访问====");
        //静态内部类对象创建与成员访问
        OuterClass.InnerClass inn = new OuterClass.InnerClass();
        inn.methodC();
    }
}*/


//实例内部类中初始化static修饰的final常量
/*
public class OuterClass{
    private int a;
    static int b;
    int c;

    public void methodA(){
        a = 10;
        System.out.println(a);
    }

    public static void methodB(){
        b = 20;
        System.out.println(b);
    }

    //实例内部类：未被static修饰
    class InnerClass{

        //public static int d = 10;//实例内部类不能定义静态成员变量
        public static final int d = 10;//但是我们可以加final来修饰
        //final：定义常量，常量是在程序编译的时候确定的，一旦初始化，就不能修改了
    }

    public static void main(String[] args) {
        //外部类：对象创建及成员访问
        OuterClass out = new OuterClass();
        System.out.println(out.a);
        System.out.println(out.b);
        System.out.println(out.c);
        out.methodA();
        out.methodB();

        System.out.println("====以下是实例内部类的访问====");
        //要访问实例内部类中成员，必须要创建实例内部类的对象
        //而普通内部类定义与外部类成员定义位置相同，因此创建实例内部类对象时必须借助外部类

        //创建实例内部类对象
        OuterClass.InnerClass inn1 = new OuterClass().new InnerClass();

        //上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建实例化内部类对象
        OuterClass.InnerClass inn2 = out.new InnerClass();
        inn2.methodC();
    }
}*/

//局部内部类
/*public class OuterClass{
    public void methodA(){
        //局部内部类：定义在方法体内部
        //不能被public、static等访问限定符修饰
        class InnerClass{
            public void methodB(){
                System.out.println("局部内部类");
            }
        }
        InnerClass inn = new InnerClass();
        inn.methodB();
    }
}*/

/*public class OuterClass {
    public void method(){
// 局部内部类：定义在方法体内部
// 不能被public、static等访问限定符修饰
        class InnerClass{
            public void methodInnerClass(){
                System.out.println("局部内部类");
            }
        }
// 只能在该方法体内部使用，其他位置都不能用
        InnerClass innerClass = new InnerClass();
        innerClass.methodInnerClass();
    }
    public static void main(String[] args) {
// OutClass.InnerClass innerClass = null; 编译失败
    }
}*/
